Add @livekit/agents-plugin-speechify: streaming text-to-speech with
word-level timestamps via the official @speechify/api SDK. Chunks
streamed input into sequential /audio/speech calls, emitting audio and
timed transcripts per sentence (streaming + alignedTranscript). Maintained
by Speechify (Speechify-AI/livekit-plugin-js).

… drop model cast)

The SDK v3.0.0 renamed the auth constructor option from apiKey to token, and
v3.0.1's GetSpeechRequest.Model union now includes simba-3.0 and simba-3.2
natively so the plugin no longer needs to widen it via a cast.

- plugins/speechify/package.json: @speechify/api ^2.0.0 -> ^3.0.1
- plugins/speechify/src/tts.ts:
  - rename public TTSOptions.apiKey -> token; pass through to
    new SpeechifyClient({ token, baseUrl })
  - update JSDoc + local variable + Omit-union for updateOptions
  - drop the `opts.model as Speechify.GetSpeechRequest.Model` cast + comment;
    v3.0.1's Model union already covers simba-english / simba-multilingual /
    simba-3.0 / simba-3.2
- pnpm-lock.yaml: refreshed

Addresses Devin review findings on livekit#1968 that both
Chunked and Synthesize streams close `this.queue` in their run()
catch blocks before re-throwing. The base class already closes the
queue in its own `finally` after run() returns, and it retries run()
on retryable APIErrors - so closing on error made the next retry's
`queue.put(...)` throw 'Queue is closed', turning transient network
errors into permanent failures.

Matches the guard the minimax plugin documents on its own catch.

Addresses Devin review finding on livekit#1968: calling
`sentenceStream.close()` immediately after `endInput()` closes the
tokenizer's output queue before its internal async loop has a chance
to flush the last buffered sentence, so the final `queue.put(token)`
throws 'Queue is closed' and consume() never sees the tail. Result:
the last sentence of a TTS response could be silently dropped.

Matches the neuphonic plugin pattern: only call endInput(), let the
tokenizer close its own output queue when its input drains.

- align auth arg with sibling plugins (was `token`, now `apiKey`)
- drop `client?: SpeechifyClient` option and `get client()` getter
- move the SDK call into an `@internal` `_synthesize` on TTS that returns
  `{ audio, timed }` in LiveKit-owned types
- revert `package.json` author to LiveKit
- drop "maintained by Speechify" paragraph from the plugin README

verified `dist/tts.d.ts` no longer references any `Speechify*` SDK types.

Devin re-review (livekit#1968):

- TTS.synthesize and ChunkedStream now accept + forward `abortSignal` to
  super() so external cancels reach the one-shot request path (matches
  the abstract signature in agents/src/tts/tts.ts and the cartesia plugin)
- SynthesizeStream now emits `final: true` exactly once, on the last
  frame of the whole reply (previously per-sentence, which dropped
  sentences 2..N from the base-class metrics because flush() only
  records one pending metric text per reply). Matches elevenlabs/cartesia.

The buffer-one deferral in the previous commit meant `cumulativeDuration`
lagged one frame behind actual produced audio, so every sentence after the
first got a slightly early offset for its word marks (Devin re-review).

Track the total emitted duration independently: advance `offsetSeconds` by
the entire sentence's frame duration right after synthesis, before the
deferral loop. The deferral still governs when `final: true` fires, but
timestamps no longer share state with it.

ChunkedStream computed its timeout only from the optional connOptions
param, leaving it undefined (no timeout) when synthesize() is called
without explicit connOptions. SynthesizeStream already reads
this.connOptions.timeoutMs (which the base class defaults to
DEFAULT_API_CONNECT_OPTIONS) - mirror that here so a one-shot
synthesis request can't hang indefinitely.